package com.icen.utils.comm;

import java.util.List;
import java.util.Map;

/**
 * Validation Utils Class
 * 
 * @author IcenHan
 * 
 */
public class ValidateUtils {

	/**
	 * 验证Object是否为空
	 * 
	 * @param obj
	 *            需要验证的Object
	 * @return boolean
	 */
	public static boolean isEmpty(Object obj) {
		return obj == null;
	}

	/**
	 * 验证字符串是否为空
	 * 
	 * @param str
	 *            需要验证的字符串
	 * @return boolean
	 */
	public static boolean isEmpty(String str) {
		return (str == null || str.length() == 0);
	}

	/**
	 * 验证Map集合是否为空
	 * 
	 * @param map
	 *            需要验证的Map集合
	 * @return boolean
	 */
	public static <K, V> boolean isEmpty(Map<K, V> map) {
		return (map == null || map.size() == 0);
	}

	/**
	 * 验证数组是否为空
	 * 
	 * @param array
	 *            需要验证的数组
	 * @return boolean
	 */
	public static <V> boolean isEmpty(V[] array) {
		return (array == null || array.length == 0);
	}

	/**
	 * 验证List集合是否为空
	 * 
	 * @param list
	 *            需要验证的List集合
	 * @return boolean
	 */
	public static <V> boolean isEmpty(List<V> list) {
		return (list == null || list.size() == 0);
	}

	/**
	 * 验证字符串是否空白
	 * 
	 * @param str
	 *            需要验证的字符串
	 * @return boolean
	 */
	public static boolean isBlank(String str) {
		return (str == null || str.trim().length() == 0);
	}

	/**
	 * 验证某个字符串中是否包含某段字符串或某个字符
	 * 
	 * @param sourceStr
	 *            需要验证的字符串
	 * @param str
	 *            是否包含的字符串或字符
	 * @return boolean
	 */
	public static boolean isHas(String sourceStr, String str) {
		return ValidateUtils.isEmpty(sourceStr) ? false : sourceStr
				.contains(str);
	}

	/**
	 * 判断数组中是否有某个值
	 * 
	 * @param array
	 *            需要验证的数组
	 * @param obj
	 *            是否包含的对象
	 * @return boolean
	 */
	public static <V> boolean isHas(V[] array, V value) {
		if (!ValidateUtils.isEmpty(array)) {
			for (int i = 0; i < array.length; i++) {
				if (ValidateUtils.isEquals(array[i], value)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 判断List集合中是否有某个值
	 * 
	 * @param list
	 *            需要验证的List集合
	 * @param value
	 *            是否包含的对象
	 * @return boolean
	 */
	public static <V> boolean isHas(List<V> list, V value) {
		return ValidateUtils.isEmpty(list) ? false : list.contains(value);
	}

	/**
	 * 验证两个对象是否相同
	 * 
	 * @param actualObj
	 *            实际对象
	 * @param expectedObj
	 *            预期对象
	 * @return boolean
	 */
	public static boolean isEquals(Object actualObj, Object expectedObj) {
		return actualObj == expectedObj
				|| (actualObj == null ? expectedObj == null : actualObj
						.equals(expectedObj));
	}

	/**
	 * 比较两个字符串是否相同
	 * 
	 * @param actualStr
	 *            实际字符串
	 * @param expectedStr
	 *            预期字符串
	 * @return boolean
	 */
	public static boolean isEquals(String actualStr, String expectedStr) {
		return ValidateUtils.isEquals(actualStr, expectedStr);
	}

	/**
	 * 比较两个List集合是否相同
	 * 
	 * @param actualList
	 *            实际List集合
	 * @param expectedList
	 *            预期List集合
	 * @return boolean
	 */
	public static <V> boolean isEquals(List<V> actualList, List<V> expectedList) {
		if (actualList == null) {
			return expectedList == null;
		}
		if (expectedList == null) {
			return false;
		}
		if (actualList.size() != expectedList.size()) {
			return false;
		}
		for (int i = 0; i < actualList.size(); i++) {
			if (!ValidateUtils.isEquals(actualList.get(i), expectedList.get(i))) {
				return false;
			}
		}
		return true;
	}
}
